#include "config.h"

void LoadFile::parse_save_file(const std::string& path)
{
    std::string data;
    std::ifstream infile(path, std::ios::in);

    if (!infile.is_open()) {
        std::println("无法打开 save.nano 文件");
        return;
    }

    // 修复：读取文件内容到 data（假设文件是单行，如 "save_path=C:/xxx"）
    std::getline(infile, data); // 读取整行内容
    infile.close(); // 读取后关闭文件

    std::stringstream ss(data);
    std::string token;
    std::vector<std::string> tokens;
    char delimiter = '=';

    while (getline(ss, token, delimiter)) {
        tokens.push_back(token);
    }

    // 检查 tokens 长度，避免越界（健壮性处理）
    if (tokens.size() < 2) {
        std::println("save.nano 格式错误，缺少 '=' 分隔符");
        return;
    }

    save_file = tokens.at(1);
    if (save_file.empty()) {
        std::println("路径不能为空");
    }
}

void LoadFile::parse_port_file(const std::string& json_path)
{
    // 1. 定义 JSON 文件路径（确保路径正确，相对于程序运行目录）

    std::ifstream json_file(json_path, std::ios::in);

    // 2. 检查文件是否打开成功
    if (!json_file.is_open()) {
        std::println("无法打开 JSON 文件：{}", json_path);
        return;
    }

    try {
        // 3. 读取 JSON 文件内容并解析为 json 对象
        nlohmann::json json_data;
        json_file >> json_data; // 从文件流解析 JSON
        json_file.close();      // 解析后关闭文件

        // 4. 遍历 JSON 的所有键值对（key=compass/depth 等，value=串口信息）
        // json_data 是 "对象类型"，用 for 循环遍历其成员
        for (auto& [json_key, json_value] : json_data.items()) {
            // 4.1 初始化一个 Serialnfo 对象，将 JSON 字段赋值给结构体
            Serialnfo serial;
            // 从 JSON 中提取字段（注意字段名要与 JSON 完全一致，区分大小写）
            serial.portName = json_value["port"].get<std::string>();       // 字符串类型
            serial.baudRate = json_value["baud_rate"].get<int>();          // 整数类型
            serial.parity = json_value["parity"].get<int>();              // 整数类型
            serial.dataBits = json_value["data_bits"].get<int>();          // 整数类型
            serial.stopBits = json_value["stop_bits"].get<int>();          // 整数类型
            serial.enable = json_value["enable"].get<bool>();              // 布尔类型
            serial.url = json_value["url"].get<std::string>();

            // 4.2 将键值对插入 unordered_map（key=json_key，value=serial）
            serials[json_key] = serial;

            // （可选）打印解析结果，验证是否正确
            std::println("解析到串口 [{}]:", json_key);
            std::println("  端口: {}", serial.portName);
            std::println("  波特率: {}", serial.baudRate);
            std::println("  校验位: {}", serial.parity);
            std::println("  数据位: {}", serial.dataBits);
            std::println("  停止位: {}", serial.stopBits);
            std::println("  使能: {}", serial.enable ? "是" : "否");
            std::println("  URL: {}\n", serial.url);
        }

        std::println("JSON 解析完成，共获取 {} 个串口配置", serials.size());

    }
    catch (const nlohmann::json::exception& e) {
        // 5. 捕获 JSON 解析错误（如字段缺失、类型不匹配）
        std::println("JSON 解析错误：{}", e.what());
        json_file.close();
        return;
    }
}

void LoadFile::parse_timeout_file(const std::string& path)
{
    std::string line;
    std::ifstream infile(path, std::ios::in);

    if (!infile.is_open()) {
        std::println("无法打开 timeout.nano 文件");
        return;
    }

    // 读取所有行（不再只读一行）
    while (std::getline(infile, line)) {
        // 跳过空行
        if (line.empty()) continue;

        std::stringstream ss(line);
        std::string token;
        std::vector<std::string> tokens;
        char delimiter = '=';

        while (getline(ss, token, delimiter)) {
            // 去除 token 中的引号和前后空格（处理 "second" 这种带引号的键）
            token.erase(remove_if(token.begin(), token.end(), [](char c) {
                return c == '"' || isspace(c);
                }), token.end());
            tokens.push_back(token);
        }

        // 检查格式是否正确（至少包含键和值）
        if (tokens.size() < 2) {
            std::println("timeout.nano 行格式错误：{}", line);
            continue;
        }

        // 提取 "second" 对应的数值
        if (tokens[0] == "second") {
            try {
                // 转换字符串为整数（如 "2" → 2）
                timeout_seconds = std::stoi(tokens[1]);
                if (timeout_seconds <= 0) {
                    std::println("警告：超时时间必须为正数，已使用默认值 2");
                    timeout_seconds = 2; // 确保为正数
                }
                else {
                    std::println("成功读取超时时间：{} 秒", timeout_seconds);
                }
            }
            catch (const std::exception& e) {
                // 处理转换失败（如值不是整数）
                std::println("timeout.nano 中 second 格式错误：{}，已使用默认值 2", e.what());
                timeout_seconds = 2;
            }
        }
        // 可选：处理 "timeout" 配置（如果需要）
        else if (tokens[0] == "timeout") {
            timeout_file = tokens[1]; // 保留原逻辑，存储 timeout 路径
            std::println("成功读取 timeout 路径：{}", timeout_file);
        }
    }

    infile.close();

    // 最终校验：如果全程未读取到 second，使用默认值
    if (timeout_seconds <= 0) {
        timeout_seconds = 2;
        std::println("未在 timeout.nano 中找到有效 second 配置，使用默认值 2 秒");
    }
}
